# Generated by the gRPC Python protocol compiler plugin. DO NOT EDIT!
import grpc

from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
from . import trading_pb2 as proto_dot_api_dot_trading__pb2
from .. import governance_pb2 as proto_dot_governance__pb2
from .. import vega_pb2 as proto_dot_vega__pb2


class tradingStub(object):
    """Missing associated documentation comment in .proto file"""

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.PrepareSubmitOrder = channel.unary_unary(
                '/api.trading/PrepareSubmitOrder',
                request_serializer=proto_dot_api_dot_trading__pb2.SubmitOrderRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PrepareSubmitOrderResponse.FromString,
                )
        self.PrepareCancelOrder = channel.unary_unary(
                '/api.trading/PrepareCancelOrder',
                request_serializer=proto_dot_api_dot_trading__pb2.CancelOrderRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PrepareCancelOrderResponse.FromString,
                )
        self.PrepareAmendOrder = channel.unary_unary(
                '/api.trading/PrepareAmendOrder',
                request_serializer=proto_dot_api_dot_trading__pb2.AmendOrderRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PrepareAmendOrderResponse.FromString,
                )
        self.NotifyTraderAccount = channel.unary_unary(
                '/api.trading/NotifyTraderAccount',
                request_serializer=proto_dot_api_dot_trading__pb2.NotifyTraderAccountRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.NotifyTraderAccountResponse.FromString,
                )
        self.Withdraw = channel.unary_unary(
                '/api.trading/Withdraw',
                request_serializer=proto_dot_api_dot_trading__pb2.WithdrawRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.WithdrawResponse.FromString,
                )
        self.SubmitTransaction = channel.unary_unary(
                '/api.trading/SubmitTransaction',
                request_serializer=proto_dot_api_dot_trading__pb2.SubmitTransactionRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.SubmitTransactionResponse.FromString,
                )
        self.PrepareProposal = channel.unary_unary(
                '/api.trading/PrepareProposal',
                request_serializer=proto_dot_api_dot_trading__pb2.PrepareProposalRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PrepareProposalResponse.FromString,
                )
        self.PrepareVote = channel.unary_unary(
                '/api.trading/PrepareVote',
                request_serializer=proto_dot_api_dot_trading__pb2.PrepareVoteRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PrepareVoteResponse.FromString,
                )
        self.PropagateChainEvent = channel.unary_unary(
                '/api.trading/PropagateChainEvent',
                request_serializer=proto_dot_api_dot_trading__pb2.PropagateChainEventRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PropagateChainEventResponse.FromString,
                )


class tradingServicer(object):
    """Missing associated documentation comment in .proto file"""

    def PrepareSubmitOrder(self, request, context):
        """Prepare a submit order request
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareCancelOrder(self, request, context):
        """Cancel an Order
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareAmendOrder(self, request, context):
        """Amend an Order
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def NotifyTraderAccount(self, request, context):
        """Request balance increase
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Withdraw(self, request, context):
        """Request withdrawal
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def SubmitTransaction(self, request, context):
        """Submit a signed transaction
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareProposal(self, request, context):
        """Governance

        Prepare proposal that can be sent out to the chain (via SubmitTransaction)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PrepareVote(self, request, context):
        """Prepare a vote to be put on the chain (via SubmitTransaction)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PropagateChainEvent(self, request, context):
        """chain events
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_tradingServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'PrepareSubmitOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareSubmitOrder,
                    request_deserializer=proto_dot_api_dot_trading__pb2.SubmitOrderRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PrepareSubmitOrderResponse.SerializeToString,
            ),
            'PrepareCancelOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareCancelOrder,
                    request_deserializer=proto_dot_api_dot_trading__pb2.CancelOrderRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PrepareCancelOrderResponse.SerializeToString,
            ),
            'PrepareAmendOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareAmendOrder,
                    request_deserializer=proto_dot_api_dot_trading__pb2.AmendOrderRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PrepareAmendOrderResponse.SerializeToString,
            ),
            'NotifyTraderAccount': grpc.unary_unary_rpc_method_handler(
                    servicer.NotifyTraderAccount,
                    request_deserializer=proto_dot_api_dot_trading__pb2.NotifyTraderAccountRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.NotifyTraderAccountResponse.SerializeToString,
            ),
            'Withdraw': grpc.unary_unary_rpc_method_handler(
                    servicer.Withdraw,
                    request_deserializer=proto_dot_api_dot_trading__pb2.WithdrawRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.WithdrawResponse.SerializeToString,
            ),
            'SubmitTransaction': grpc.unary_unary_rpc_method_handler(
                    servicer.SubmitTransaction,
                    request_deserializer=proto_dot_api_dot_trading__pb2.SubmitTransactionRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.SubmitTransactionResponse.SerializeToString,
            ),
            'PrepareProposal': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareProposal,
                    request_deserializer=proto_dot_api_dot_trading__pb2.PrepareProposalRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PrepareProposalResponse.SerializeToString,
            ),
            'PrepareVote': grpc.unary_unary_rpc_method_handler(
                    servicer.PrepareVote,
                    request_deserializer=proto_dot_api_dot_trading__pb2.PrepareVoteRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PrepareVoteResponse.SerializeToString,
            ),
            'PropagateChainEvent': grpc.unary_unary_rpc_method_handler(
                    servicer.PropagateChainEvent,
                    request_deserializer=proto_dot_api_dot_trading__pb2.PropagateChainEventRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PropagateChainEventResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'api.trading', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class trading(object):
    """Missing associated documentation comment in .proto file"""

    @staticmethod
    def PrepareSubmitOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/PrepareSubmitOrder',
            proto_dot_api_dot_trading__pb2.SubmitOrderRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PrepareSubmitOrderResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareCancelOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/PrepareCancelOrder',
            proto_dot_api_dot_trading__pb2.CancelOrderRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PrepareCancelOrderResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareAmendOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/PrepareAmendOrder',
            proto_dot_api_dot_trading__pb2.AmendOrderRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PrepareAmendOrderResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def NotifyTraderAccount(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/NotifyTraderAccount',
            proto_dot_api_dot_trading__pb2.NotifyTraderAccountRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.NotifyTraderAccountResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Withdraw(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/Withdraw',
            proto_dot_api_dot_trading__pb2.WithdrawRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.WithdrawResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def SubmitTransaction(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/SubmitTransaction',
            proto_dot_api_dot_trading__pb2.SubmitTransactionRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.SubmitTransactionResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareProposal(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/PrepareProposal',
            proto_dot_api_dot_trading__pb2.PrepareProposalRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PrepareProposalResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PrepareVote(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/PrepareVote',
            proto_dot_api_dot_trading__pb2.PrepareVoteRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PrepareVoteResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PropagateChainEvent(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading/PropagateChainEvent',
            proto_dot_api_dot_trading__pb2.PropagateChainEventRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PropagateChainEventResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)


class trading_dataStub(object):
    """Missing associated documentation comment in .proto file"""

    def __init__(self, channel):
        """Constructor.

        Args:
            channel: A grpc.Channel.
        """
        self.MarketAccounts = channel.unary_unary(
                '/api.trading_data/MarketAccounts',
                request_serializer=proto_dot_api_dot_trading__pb2.MarketAccountsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.MarketAccountsResponse.FromString,
                )
        self.PartyAccounts = channel.unary_unary(
                '/api.trading_data/PartyAccounts',
                request_serializer=proto_dot_api_dot_trading__pb2.PartyAccountsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PartyAccountsResponse.FromString,
                )
        self.Candles = channel.unary_unary(
                '/api.trading_data/Candles',
                request_serializer=proto_dot_api_dot_trading__pb2.CandlesRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.CandlesResponse.FromString,
                )
        self.MarketDataByID = channel.unary_unary(
                '/api.trading_data/MarketDataByID',
                request_serializer=proto_dot_api_dot_trading__pb2.MarketDataByIDRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.MarketDataByIDResponse.FromString,
                )
        self.MarketsData = channel.unary_unary(
                '/api.trading_data/MarketsData',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.MarketsDataResponse.FromString,
                )
        self.MarketByID = channel.unary_unary(
                '/api.trading_data/MarketByID',
                request_serializer=proto_dot_api_dot_trading__pb2.MarketByIDRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.MarketByIDResponse.FromString,
                )
        self.MarketDepth = channel.unary_unary(
                '/api.trading_data/MarketDepth',
                request_serializer=proto_dot_api_dot_trading__pb2.MarketDepthRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.MarketDepthResponse.FromString,
                )
        self.Markets = channel.unary_unary(
                '/api.trading_data/Markets',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.MarketsResponse.FromString,
                )
        self.OrderByMarketAndID = channel.unary_unary(
                '/api.trading_data/OrderByMarketAndID',
                request_serializer=proto_dot_api_dot_trading__pb2.OrderByMarketAndIdRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.OrderByMarketAndIdResponse.FromString,
                )
        self.OrderByReference = channel.unary_unary(
                '/api.trading_data/OrderByReference',
                request_serializer=proto_dot_api_dot_trading__pb2.OrderByReferenceRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.OrderByReferenceResponse.FromString,
                )
        self.OrdersByMarket = channel.unary_unary(
                '/api.trading_data/OrdersByMarket',
                request_serializer=proto_dot_api_dot_trading__pb2.OrdersByMarketRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.OrdersByMarketResponse.FromString,
                )
        self.OrdersByParty = channel.unary_unary(
                '/api.trading_data/OrdersByParty',
                request_serializer=proto_dot_api_dot_trading__pb2.OrdersByPartyRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.OrdersByPartyResponse.FromString,
                )
        self.OrderByID = channel.unary_unary(
                '/api.trading_data/OrderByID',
                request_serializer=proto_dot_api_dot_trading__pb2.OrderByIDRequest.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.Order.FromString,
                )
        self.OrderByReferenceID = channel.unary_unary(
                '/api.trading_data/OrderByReferenceID',
                request_serializer=proto_dot_api_dot_trading__pb2.OrderByReferenceIDRequest.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.Order.FromString,
                )
        self.OrderVersionsByID = channel.unary_unary(
                '/api.trading_data/OrderVersionsByID',
                request_serializer=proto_dot_api_dot_trading__pb2.OrderVersionsByIDRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.OrderVersionsResponse.FromString,
                )
        self.MarginLevels = channel.unary_unary(
                '/api.trading_data/MarginLevels',
                request_serializer=proto_dot_api_dot_trading__pb2.MarginLevelsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.MarginLevelsResponse.FromString,
                )
        self.Parties = channel.unary_unary(
                '/api.trading_data/Parties',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PartiesResponse.FromString,
                )
        self.PartyByID = channel.unary_unary(
                '/api.trading_data/PartyByID',
                request_serializer=proto_dot_api_dot_trading__pb2.PartyByIDRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PartyByIDResponse.FromString,
                )
        self.PositionsByParty = channel.unary_unary(
                '/api.trading_data/PositionsByParty',
                request_serializer=proto_dot_api_dot_trading__pb2.PositionsByPartyRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.PositionsByPartyResponse.FromString,
                )
        self.LastTrade = channel.unary_unary(
                '/api.trading_data/LastTrade',
                request_serializer=proto_dot_api_dot_trading__pb2.LastTradeRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.LastTradeResponse.FromString,
                )
        self.TradesByMarket = channel.unary_unary(
                '/api.trading_data/TradesByMarket',
                request_serializer=proto_dot_api_dot_trading__pb2.TradesByMarketRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.TradesByMarketResponse.FromString,
                )
        self.TradesByOrder = channel.unary_unary(
                '/api.trading_data/TradesByOrder',
                request_serializer=proto_dot_api_dot_trading__pb2.TradesByOrderRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.TradesByOrderResponse.FromString,
                )
        self.TradesByParty = channel.unary_unary(
                '/api.trading_data/TradesByParty',
                request_serializer=proto_dot_api_dot_trading__pb2.TradesByPartyRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.TradesByPartyResponse.FromString,
                )
        self.GetProposals = channel.unary_unary(
                '/api.trading_data/GetProposals',
                request_serializer=proto_dot_api_dot_trading__pb2.GetProposalsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetProposalsResponse.FromString,
                )
        self.GetProposalsByParty = channel.unary_unary(
                '/api.trading_data/GetProposalsByParty',
                request_serializer=proto_dot_api_dot_trading__pb2.GetProposalsByPartyRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetProposalsByPartyResponse.FromString,
                )
        self.GetVotesByParty = channel.unary_unary(
                '/api.trading_data/GetVotesByParty',
                request_serializer=proto_dot_api_dot_trading__pb2.GetVotesByPartyRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetVotesByPartyResponse.FromString,
                )
        self.GetNewMarketProposals = channel.unary_unary(
                '/api.trading_data/GetNewMarketProposals',
                request_serializer=proto_dot_api_dot_trading__pb2.GetNewMarketProposalsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetNewMarketProposalsResponse.FromString,
                )
        self.GetUpdateMarketProposals = channel.unary_unary(
                '/api.trading_data/GetUpdateMarketProposals',
                request_serializer=proto_dot_api_dot_trading__pb2.GetUpdateMarketProposalsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetUpdateMarketProposalsResponse.FromString,
                )
        self.GetNetworkParametersProposals = channel.unary_unary(
                '/api.trading_data/GetNetworkParametersProposals',
                request_serializer=proto_dot_api_dot_trading__pb2.GetNetworkParametersProposalsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetNetworkParametersProposalsResponse.FromString,
                )
        self.GetNewAssetProposals = channel.unary_unary(
                '/api.trading_data/GetNewAssetProposals',
                request_serializer=proto_dot_api_dot_trading__pb2.GetNewAssetProposalsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetNewAssetProposalsResponse.FromString,
                )
        self.GetProposalByID = channel.unary_unary(
                '/api.trading_data/GetProposalByID',
                request_serializer=proto_dot_api_dot_trading__pb2.GetProposalByIDRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetProposalByIDResponse.FromString,
                )
        self.GetProposalByReference = channel.unary_unary(
                '/api.trading_data/GetProposalByReference',
                request_serializer=proto_dot_api_dot_trading__pb2.GetProposalByReferenceRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetProposalByReferenceResponse.FromString,
                )
        self.ObserveGovernance = channel.unary_stream(
                '/api.trading_data/ObserveGovernance',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=proto_dot_governance__pb2.GovernanceData.FromString,
                )
        self.ObservePartyProposals = channel.unary_stream(
                '/api.trading_data/ObservePartyProposals',
                request_serializer=proto_dot_api_dot_trading__pb2.ObservePartyProposalsRequest.SerializeToString,
                response_deserializer=proto_dot_governance__pb2.GovernanceData.FromString,
                )
        self.ObservePartyVotes = channel.unary_stream(
                '/api.trading_data/ObservePartyVotes',
                request_serializer=proto_dot_api_dot_trading__pb2.ObservePartyVotesRequest.SerializeToString,
                response_deserializer=proto_dot_governance__pb2.Vote.FromString,
                )
        self.ObserveProposalVotes = channel.unary_stream(
                '/api.trading_data/ObserveProposalVotes',
                request_serializer=proto_dot_api_dot_trading__pb2.ObserveProposalVotesRequest.SerializeToString,
                response_deserializer=proto_dot_governance__pb2.Vote.FromString,
                )
        self.Statistics = channel.unary_unary(
                '/api.trading_data/Statistics',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.Statistics.FromString,
                )
        self.GetVegaTime = channel.unary_unary(
                '/api.trading_data/GetVegaTime',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.VegaTimeResponse.FromString,
                )
        self.AccountsSubscribe = channel.unary_stream(
                '/api.trading_data/AccountsSubscribe',
                request_serializer=proto_dot_api_dot_trading__pb2.AccountsSubscribeRequest.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.Account.FromString,
                )
        self.CandlesSubscribe = channel.unary_stream(
                '/api.trading_data/CandlesSubscribe',
                request_serializer=proto_dot_api_dot_trading__pb2.CandlesSubscribeRequest.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.Candle.FromString,
                )
        self.MarginLevelsSubscribe = channel.unary_stream(
                '/api.trading_data/MarginLevelsSubscribe',
                request_serializer=proto_dot_api_dot_trading__pb2.MarginLevelsSubscribeRequest.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.MarginLevels.FromString,
                )
        self.MarketDepthSubscribe = channel.unary_stream(
                '/api.trading_data/MarketDepthSubscribe',
                request_serializer=proto_dot_api_dot_trading__pb2.MarketDepthSubscribeRequest.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.MarketDepth.FromString,
                )
        self.MarketsDataSubscribe = channel.unary_stream(
                '/api.trading_data/MarketsDataSubscribe',
                request_serializer=proto_dot_api_dot_trading__pb2.MarketsDataSubscribeRequest.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.MarketData.FromString,
                )
        self.OrdersSubscribe = channel.unary_stream(
                '/api.trading_data/OrdersSubscribe',
                request_serializer=proto_dot_api_dot_trading__pb2.OrdersSubscribeRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.OrdersStream.FromString,
                )
        self.PositionsSubscribe = channel.unary_stream(
                '/api.trading_data/PositionsSubscribe',
                request_serializer=proto_dot_api_dot_trading__pb2.PositionsSubscribeRequest.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.Position.FromString,
                )
        self.TradesSubscribe = channel.unary_stream(
                '/api.trading_data/TradesSubscribe',
                request_serializer=proto_dot_api_dot_trading__pb2.TradesSubscribeRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.TradesStream.FromString,
                )
        self.TransferResponsesSubscribe = channel.unary_stream(
                '/api.trading_data/TransferResponsesSubscribe',
                request_serializer=google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
                response_deserializer=proto_dot_vega__pb2.TransferResponse.FromString,
                )
        self.GetNodeSignaturesAggregate = channel.unary_unary(
                '/api.trading_data/GetNodeSignaturesAggregate',
                request_serializer=proto_dot_api_dot_trading__pb2.GetNodeSignaturesAggregateRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.GetNodeSignaturesAggregateResponse.FromString,
                )
        self.AssetByID = channel.unary_unary(
                '/api.trading_data/AssetByID',
                request_serializer=proto_dot_api_dot_trading__pb2.AssetByIDRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.AssetByIDResponse.FromString,
                )
        self.Assets = channel.unary_unary(
                '/api.trading_data/Assets',
                request_serializer=proto_dot_api_dot_trading__pb2.AssetsRequest.SerializeToString,
                response_deserializer=proto_dot_api_dot_trading__pb2.AssetsResponse.FromString,
                )


class trading_dataServicer(object):
    """Missing associated documentation comment in .proto file"""

    def MarketAccounts(self, request, context):
        """Accounts

        Get a list of Accounts by Market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PartyAccounts(self, request, context):
        """Get a list of Accounts by Party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Candles(self, request, context):
        """Candles

        Get a list of Candles by Market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketDataByID(self, request, context):
        """Market Data

        Get Market Data by MarketID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketsData(self, request, context):
        """Get a list of Market Data
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketByID(self, request, context):
        """Markets

        Get a Market by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketDepth(self, request, context):
        """Get Market Depth
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Markets(self, request, context):
        """Get a list of Markets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderByMarketAndID(self, request, context):
        """Orders

        Get an Order by Market and OrderID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderByReference(self, request, context):
        """Get an Order by Pending Order reference (UUID)
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrdersByMarket(self, request, context):
        """Get a list of Orders by Market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrdersByParty(self, request, context):
        """Get a list of Orders by Party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderByID(self, request, context):
        """Get a specific order by orderID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderByReferenceID(self, request, context):
        """Get a specific order by referenceID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrderVersionsByID(self, request, context):
        """Get all versions of the order by its orderID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarginLevels(self, request, context):
        """Parties

        Get Margin Levels by PartyID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Parties(self, request, context):
        """Get a list of Parties
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PartyByID(self, request, context):
        """Get a Party by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PositionsByParty(self, request, context):
        """Positions

        Get a list of Positions by Party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def LastTrade(self, request, context):
        """Trades

        Get latest Trade
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TradesByMarket(self, request, context):
        """Get a list of Trades by Market
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TradesByOrder(self, request, context):
        """Get a list of Trades by Order
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TradesByParty(self, request, context):
        """Get a list of Trades by Party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProposals(self, request, context):
        """Governance

        Get governance data (proposals and votes) for all proposals
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProposalsByParty(self, request, context):
        """Get governance data (proposals and votes) for proposals by party authoring them
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetVotesByParty(self, request, context):
        """Get votes by party casting them
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNewMarketProposals(self, request, context):
        """Get governance data (proposals and votes) for proposals that aim creating new markets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetUpdateMarketProposals(self, request, context):
        """Get governance data (proposals and votes) for proposals that aim updating markets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNetworkParametersProposals(self, request, context):
        """Get governance data (proposals and votes) for proposals that aim updating Vega network parameters
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNewAssetProposals(self, request, context):
        """Get governance data (proposals and votes) for proposals aiming to create new assets
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProposalByID(self, request, context):
        """Get governance data (proposals and votes) for a proposal located by ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetProposalByReference(self, request, context):
        """Get governance data (proposals and votes) for a proposal located by reference
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObserveGovernance(self, request, context):
        """Subscribe to a stream of all governance updates
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObservePartyProposals(self, request, context):
        """Subscribe to a stream of proposal updates
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObservePartyVotes(self, request, context):
        """Subscribe to a stream of votes cast by a specific party
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def ObserveProposalVotes(self, request, context):
        """Subscribe to a stream of proposal votes
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Statistics(self, request, context):
        """Misc

        Get Statistics
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetVegaTime(self, request, context):
        """Get Time
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AccountsSubscribe(self, request, context):
        """Subscribe to a stream of Accounts
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def CandlesSubscribe(self, request, context):
        """Subscribe to a stream of Candles
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarginLevelsSubscribe(self, request, context):
        """Subscribe to a stream of Margin Levels
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketDepthSubscribe(self, request, context):
        """Subscribe to a stream of Market Depth
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def MarketsDataSubscribe(self, request, context):
        """Subscribe to a stream of Markets Data
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def OrdersSubscribe(self, request, context):
        """Subscribe to a stream of Orders
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def PositionsSubscribe(self, request, context):
        """Subscribe to a stream of Positions
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TradesSubscribe(self, request, context):
        """Subscribe to a stream of Trades
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def TransferResponsesSubscribe(self, request, context):
        """Subscribe to a stream of Transfer Responses
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def GetNodeSignaturesAggregate(self, request, context):
        """Get an aggregate of signature from all the node of the network
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def AssetByID(self, request, context):
        """Get an asset by its ID
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')

    def Assets(self, request, context):
        """Get the list of all assets in vega
        """
        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
        context.set_details('Method not implemented!')
        raise NotImplementedError('Method not implemented!')


def add_trading_dataServicer_to_server(servicer, server):
    rpc_method_handlers = {
            'MarketAccounts': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketAccounts,
                    request_deserializer=proto_dot_api_dot_trading__pb2.MarketAccountsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.MarketAccountsResponse.SerializeToString,
            ),
            'PartyAccounts': grpc.unary_unary_rpc_method_handler(
                    servicer.PartyAccounts,
                    request_deserializer=proto_dot_api_dot_trading__pb2.PartyAccountsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PartyAccountsResponse.SerializeToString,
            ),
            'Candles': grpc.unary_unary_rpc_method_handler(
                    servicer.Candles,
                    request_deserializer=proto_dot_api_dot_trading__pb2.CandlesRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.CandlesResponse.SerializeToString,
            ),
            'MarketDataByID': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketDataByID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.MarketDataByIDRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.MarketDataByIDResponse.SerializeToString,
            ),
            'MarketsData': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketsData,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.MarketsDataResponse.SerializeToString,
            ),
            'MarketByID': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketByID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.MarketByIDRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.MarketByIDResponse.SerializeToString,
            ),
            'MarketDepth': grpc.unary_unary_rpc_method_handler(
                    servicer.MarketDepth,
                    request_deserializer=proto_dot_api_dot_trading__pb2.MarketDepthRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.MarketDepthResponse.SerializeToString,
            ),
            'Markets': grpc.unary_unary_rpc_method_handler(
                    servicer.Markets,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.MarketsResponse.SerializeToString,
            ),
            'OrderByMarketAndID': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderByMarketAndID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.OrderByMarketAndIdRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.OrderByMarketAndIdResponse.SerializeToString,
            ),
            'OrderByReference': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderByReference,
                    request_deserializer=proto_dot_api_dot_trading__pb2.OrderByReferenceRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.OrderByReferenceResponse.SerializeToString,
            ),
            'OrdersByMarket': grpc.unary_unary_rpc_method_handler(
                    servicer.OrdersByMarket,
                    request_deserializer=proto_dot_api_dot_trading__pb2.OrdersByMarketRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.OrdersByMarketResponse.SerializeToString,
            ),
            'OrdersByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.OrdersByParty,
                    request_deserializer=proto_dot_api_dot_trading__pb2.OrdersByPartyRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.OrdersByPartyResponse.SerializeToString,
            ),
            'OrderByID': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderByID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.OrderByIDRequest.FromString,
                    response_serializer=proto_dot_vega__pb2.Order.SerializeToString,
            ),
            'OrderByReferenceID': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderByReferenceID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.OrderByReferenceIDRequest.FromString,
                    response_serializer=proto_dot_vega__pb2.Order.SerializeToString,
            ),
            'OrderVersionsByID': grpc.unary_unary_rpc_method_handler(
                    servicer.OrderVersionsByID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.OrderVersionsByIDRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.OrderVersionsResponse.SerializeToString,
            ),
            'MarginLevels': grpc.unary_unary_rpc_method_handler(
                    servicer.MarginLevels,
                    request_deserializer=proto_dot_api_dot_trading__pb2.MarginLevelsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.MarginLevelsResponse.SerializeToString,
            ),
            'Parties': grpc.unary_unary_rpc_method_handler(
                    servicer.Parties,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PartiesResponse.SerializeToString,
            ),
            'PartyByID': grpc.unary_unary_rpc_method_handler(
                    servicer.PartyByID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.PartyByIDRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PartyByIDResponse.SerializeToString,
            ),
            'PositionsByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.PositionsByParty,
                    request_deserializer=proto_dot_api_dot_trading__pb2.PositionsByPartyRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.PositionsByPartyResponse.SerializeToString,
            ),
            'LastTrade': grpc.unary_unary_rpc_method_handler(
                    servicer.LastTrade,
                    request_deserializer=proto_dot_api_dot_trading__pb2.LastTradeRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.LastTradeResponse.SerializeToString,
            ),
            'TradesByMarket': grpc.unary_unary_rpc_method_handler(
                    servicer.TradesByMarket,
                    request_deserializer=proto_dot_api_dot_trading__pb2.TradesByMarketRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.TradesByMarketResponse.SerializeToString,
            ),
            'TradesByOrder': grpc.unary_unary_rpc_method_handler(
                    servicer.TradesByOrder,
                    request_deserializer=proto_dot_api_dot_trading__pb2.TradesByOrderRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.TradesByOrderResponse.SerializeToString,
            ),
            'TradesByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.TradesByParty,
                    request_deserializer=proto_dot_api_dot_trading__pb2.TradesByPartyRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.TradesByPartyResponse.SerializeToString,
            ),
            'GetProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProposals,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetProposalsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetProposalsResponse.SerializeToString,
            ),
            'GetProposalsByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProposalsByParty,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetProposalsByPartyRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetProposalsByPartyResponse.SerializeToString,
            ),
            'GetVotesByParty': grpc.unary_unary_rpc_method_handler(
                    servicer.GetVotesByParty,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetVotesByPartyRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetVotesByPartyResponse.SerializeToString,
            ),
            'GetNewMarketProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNewMarketProposals,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetNewMarketProposalsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetNewMarketProposalsResponse.SerializeToString,
            ),
            'GetUpdateMarketProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetUpdateMarketProposals,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetUpdateMarketProposalsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetUpdateMarketProposalsResponse.SerializeToString,
            ),
            'GetNetworkParametersProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNetworkParametersProposals,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetNetworkParametersProposalsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetNetworkParametersProposalsResponse.SerializeToString,
            ),
            'GetNewAssetProposals': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNewAssetProposals,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetNewAssetProposalsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetNewAssetProposalsResponse.SerializeToString,
            ),
            'GetProposalByID': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProposalByID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetProposalByIDRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetProposalByIDResponse.SerializeToString,
            ),
            'GetProposalByReference': grpc.unary_unary_rpc_method_handler(
                    servicer.GetProposalByReference,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetProposalByReferenceRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetProposalByReferenceResponse.SerializeToString,
            ),
            'ObserveGovernance': grpc.unary_stream_rpc_method_handler(
                    servicer.ObserveGovernance,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=proto_dot_governance__pb2.GovernanceData.SerializeToString,
            ),
            'ObservePartyProposals': grpc.unary_stream_rpc_method_handler(
                    servicer.ObservePartyProposals,
                    request_deserializer=proto_dot_api_dot_trading__pb2.ObservePartyProposalsRequest.FromString,
                    response_serializer=proto_dot_governance__pb2.GovernanceData.SerializeToString,
            ),
            'ObservePartyVotes': grpc.unary_stream_rpc_method_handler(
                    servicer.ObservePartyVotes,
                    request_deserializer=proto_dot_api_dot_trading__pb2.ObservePartyVotesRequest.FromString,
                    response_serializer=proto_dot_governance__pb2.Vote.SerializeToString,
            ),
            'ObserveProposalVotes': grpc.unary_stream_rpc_method_handler(
                    servicer.ObserveProposalVotes,
                    request_deserializer=proto_dot_api_dot_trading__pb2.ObserveProposalVotesRequest.FromString,
                    response_serializer=proto_dot_governance__pb2.Vote.SerializeToString,
            ),
            'Statistics': grpc.unary_unary_rpc_method_handler(
                    servicer.Statistics,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=proto_dot_vega__pb2.Statistics.SerializeToString,
            ),
            'GetVegaTime': grpc.unary_unary_rpc_method_handler(
                    servicer.GetVegaTime,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.VegaTimeResponse.SerializeToString,
            ),
            'AccountsSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.AccountsSubscribe,
                    request_deserializer=proto_dot_api_dot_trading__pb2.AccountsSubscribeRequest.FromString,
                    response_serializer=proto_dot_vega__pb2.Account.SerializeToString,
            ),
            'CandlesSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.CandlesSubscribe,
                    request_deserializer=proto_dot_api_dot_trading__pb2.CandlesSubscribeRequest.FromString,
                    response_serializer=proto_dot_vega__pb2.Candle.SerializeToString,
            ),
            'MarginLevelsSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.MarginLevelsSubscribe,
                    request_deserializer=proto_dot_api_dot_trading__pb2.MarginLevelsSubscribeRequest.FromString,
                    response_serializer=proto_dot_vega__pb2.MarginLevels.SerializeToString,
            ),
            'MarketDepthSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.MarketDepthSubscribe,
                    request_deserializer=proto_dot_api_dot_trading__pb2.MarketDepthSubscribeRequest.FromString,
                    response_serializer=proto_dot_vega__pb2.MarketDepth.SerializeToString,
            ),
            'MarketsDataSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.MarketsDataSubscribe,
                    request_deserializer=proto_dot_api_dot_trading__pb2.MarketsDataSubscribeRequest.FromString,
                    response_serializer=proto_dot_vega__pb2.MarketData.SerializeToString,
            ),
            'OrdersSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.OrdersSubscribe,
                    request_deserializer=proto_dot_api_dot_trading__pb2.OrdersSubscribeRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.OrdersStream.SerializeToString,
            ),
            'PositionsSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.PositionsSubscribe,
                    request_deserializer=proto_dot_api_dot_trading__pb2.PositionsSubscribeRequest.FromString,
                    response_serializer=proto_dot_vega__pb2.Position.SerializeToString,
            ),
            'TradesSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.TradesSubscribe,
                    request_deserializer=proto_dot_api_dot_trading__pb2.TradesSubscribeRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.TradesStream.SerializeToString,
            ),
            'TransferResponsesSubscribe': grpc.unary_stream_rpc_method_handler(
                    servicer.TransferResponsesSubscribe,
                    request_deserializer=google_dot_protobuf_dot_empty__pb2.Empty.FromString,
                    response_serializer=proto_dot_vega__pb2.TransferResponse.SerializeToString,
            ),
            'GetNodeSignaturesAggregate': grpc.unary_unary_rpc_method_handler(
                    servicer.GetNodeSignaturesAggregate,
                    request_deserializer=proto_dot_api_dot_trading__pb2.GetNodeSignaturesAggregateRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.GetNodeSignaturesAggregateResponse.SerializeToString,
            ),
            'AssetByID': grpc.unary_unary_rpc_method_handler(
                    servicer.AssetByID,
                    request_deserializer=proto_dot_api_dot_trading__pb2.AssetByIDRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.AssetByIDResponse.SerializeToString,
            ),
            'Assets': grpc.unary_unary_rpc_method_handler(
                    servicer.Assets,
                    request_deserializer=proto_dot_api_dot_trading__pb2.AssetsRequest.FromString,
                    response_serializer=proto_dot_api_dot_trading__pb2.AssetsResponse.SerializeToString,
            ),
    }
    generic_handler = grpc.method_handlers_generic_handler(
            'api.trading_data', rpc_method_handlers)
    server.add_generic_rpc_handlers((generic_handler,))


 # This class is part of an EXPERIMENTAL API.
class trading_data(object):
    """Missing associated documentation comment in .proto file"""

    @staticmethod
    def MarketAccounts(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/MarketAccounts',
            proto_dot_api_dot_trading__pb2.MarketAccountsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.MarketAccountsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PartyAccounts(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/PartyAccounts',
            proto_dot_api_dot_trading__pb2.PartyAccountsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PartyAccountsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Candles(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/Candles',
            proto_dot_api_dot_trading__pb2.CandlesRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.CandlesResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketDataByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/MarketDataByID',
            proto_dot_api_dot_trading__pb2.MarketDataByIDRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.MarketDataByIDResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketsData(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/MarketsData',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            proto_dot_api_dot_trading__pb2.MarketsDataResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/MarketByID',
            proto_dot_api_dot_trading__pb2.MarketByIDRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.MarketByIDResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketDepth(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/MarketDepth',
            proto_dot_api_dot_trading__pb2.MarketDepthRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.MarketDepthResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Markets(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/Markets',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            proto_dot_api_dot_trading__pb2.MarketsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderByMarketAndID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/OrderByMarketAndID',
            proto_dot_api_dot_trading__pb2.OrderByMarketAndIdRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.OrderByMarketAndIdResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderByReference(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/OrderByReference',
            proto_dot_api_dot_trading__pb2.OrderByReferenceRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.OrderByReferenceResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrdersByMarket(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/OrdersByMarket',
            proto_dot_api_dot_trading__pb2.OrdersByMarketRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.OrdersByMarketResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrdersByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/OrdersByParty',
            proto_dot_api_dot_trading__pb2.OrdersByPartyRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.OrdersByPartyResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/OrderByID',
            proto_dot_api_dot_trading__pb2.OrderByIDRequest.SerializeToString,
            proto_dot_vega__pb2.Order.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderByReferenceID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/OrderByReferenceID',
            proto_dot_api_dot_trading__pb2.OrderByReferenceIDRequest.SerializeToString,
            proto_dot_vega__pb2.Order.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrderVersionsByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/OrderVersionsByID',
            proto_dot_api_dot_trading__pb2.OrderVersionsByIDRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.OrderVersionsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarginLevels(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/MarginLevels',
            proto_dot_api_dot_trading__pb2.MarginLevelsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.MarginLevelsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Parties(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/Parties',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            proto_dot_api_dot_trading__pb2.PartiesResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PartyByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/PartyByID',
            proto_dot_api_dot_trading__pb2.PartyByIDRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PartyByIDResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PositionsByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/PositionsByParty',
            proto_dot_api_dot_trading__pb2.PositionsByPartyRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.PositionsByPartyResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def LastTrade(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/LastTrade',
            proto_dot_api_dot_trading__pb2.LastTradeRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.LastTradeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TradesByMarket(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/TradesByMarket',
            proto_dot_api_dot_trading__pb2.TradesByMarketRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.TradesByMarketResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TradesByOrder(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/TradesByOrder',
            proto_dot_api_dot_trading__pb2.TradesByOrderRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.TradesByOrderResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TradesByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/TradesByParty',
            proto_dot_api_dot_trading__pb2.TradesByPartyRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.TradesByPartyResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetProposals',
            proto_dot_api_dot_trading__pb2.GetProposalsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetProposalsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProposalsByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetProposalsByParty',
            proto_dot_api_dot_trading__pb2.GetProposalsByPartyRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetProposalsByPartyResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetVotesByParty(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetVotesByParty',
            proto_dot_api_dot_trading__pb2.GetVotesByPartyRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetVotesByPartyResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetNewMarketProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetNewMarketProposals',
            proto_dot_api_dot_trading__pb2.GetNewMarketProposalsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetNewMarketProposalsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetUpdateMarketProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetUpdateMarketProposals',
            proto_dot_api_dot_trading__pb2.GetUpdateMarketProposalsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetUpdateMarketProposalsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetNetworkParametersProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetNetworkParametersProposals',
            proto_dot_api_dot_trading__pb2.GetNetworkParametersProposalsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetNetworkParametersProposalsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetNewAssetProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetNewAssetProposals',
            proto_dot_api_dot_trading__pb2.GetNewAssetProposalsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetNewAssetProposalsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProposalByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetProposalByID',
            proto_dot_api_dot_trading__pb2.GetProposalByIDRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetProposalByIDResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetProposalByReference(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetProposalByReference',
            proto_dot_api_dot_trading__pb2.GetProposalByReferenceRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetProposalByReferenceResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObserveGovernance(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/ObserveGovernance',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            proto_dot_governance__pb2.GovernanceData.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObservePartyProposals(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/ObservePartyProposals',
            proto_dot_api_dot_trading__pb2.ObservePartyProposalsRequest.SerializeToString,
            proto_dot_governance__pb2.GovernanceData.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObservePartyVotes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/ObservePartyVotes',
            proto_dot_api_dot_trading__pb2.ObservePartyVotesRequest.SerializeToString,
            proto_dot_governance__pb2.Vote.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def ObserveProposalVotes(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/ObserveProposalVotes',
            proto_dot_api_dot_trading__pb2.ObserveProposalVotesRequest.SerializeToString,
            proto_dot_governance__pb2.Vote.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Statistics(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/Statistics',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            proto_dot_vega__pb2.Statistics.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetVegaTime(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetVegaTime',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            proto_dot_api_dot_trading__pb2.VegaTimeResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AccountsSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/AccountsSubscribe',
            proto_dot_api_dot_trading__pb2.AccountsSubscribeRequest.SerializeToString,
            proto_dot_vega__pb2.Account.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def CandlesSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/CandlesSubscribe',
            proto_dot_api_dot_trading__pb2.CandlesSubscribeRequest.SerializeToString,
            proto_dot_vega__pb2.Candle.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarginLevelsSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/MarginLevelsSubscribe',
            proto_dot_api_dot_trading__pb2.MarginLevelsSubscribeRequest.SerializeToString,
            proto_dot_vega__pb2.MarginLevels.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketDepthSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/MarketDepthSubscribe',
            proto_dot_api_dot_trading__pb2.MarketDepthSubscribeRequest.SerializeToString,
            proto_dot_vega__pb2.MarketDepth.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def MarketsDataSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/MarketsDataSubscribe',
            proto_dot_api_dot_trading__pb2.MarketsDataSubscribeRequest.SerializeToString,
            proto_dot_vega__pb2.MarketData.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def OrdersSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/OrdersSubscribe',
            proto_dot_api_dot_trading__pb2.OrdersSubscribeRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.OrdersStream.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def PositionsSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/PositionsSubscribe',
            proto_dot_api_dot_trading__pb2.PositionsSubscribeRequest.SerializeToString,
            proto_dot_vega__pb2.Position.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TradesSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/TradesSubscribe',
            proto_dot_api_dot_trading__pb2.TradesSubscribeRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.TradesStream.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def TransferResponsesSubscribe(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_stream(request, target, '/api.trading_data/TransferResponsesSubscribe',
            google_dot_protobuf_dot_empty__pb2.Empty.SerializeToString,
            proto_dot_vega__pb2.TransferResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def GetNodeSignaturesAggregate(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/GetNodeSignaturesAggregate',
            proto_dot_api_dot_trading__pb2.GetNodeSignaturesAggregateRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.GetNodeSignaturesAggregateResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def AssetByID(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/AssetByID',
            proto_dot_api_dot_trading__pb2.AssetByIDRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.AssetByIDResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)

    @staticmethod
    def Assets(request,
            target,
            options=(),
            channel_credentials=None,
            call_credentials=None,
            compression=None,
            wait_for_ready=None,
            timeout=None,
            metadata=None):
        return grpc.experimental.unary_unary(request, target, '/api.trading_data/Assets',
            proto_dot_api_dot_trading__pb2.AssetsRequest.SerializeToString,
            proto_dot_api_dot_trading__pb2.AssetsResponse.FromString,
            options, channel_credentials,
            call_credentials, compression, wait_for_ready, timeout, metadata)
